package br.com.duosoftware.orcamento.managedbeans;

import br.com.duosoftware.orcamento.daos.ConfirmacaoDAO;
import br.com.duosoftware.orcamento.daos.PlanoDeContaDAO;
import br.com.duosoftware.orcamento.daos.PlanoDeReceitaDAO;
import br.com.duosoftware.orcamento.daos.PrevisaoDeReceitaDAO;
import br.com.duosoftware.orcamento.daos.TipoOrcamentoDAO;
import br.com.duosoftware.orcamento.daos.UnidadeGestoraDAO;
import br.com.duosoftware.orcamento.daos.UnidadeOrcamentariaDAO;
import br.com.duosoftware.orcamento.entidades.Confirmacao;
import br.com.duosoftware.orcamento.entidades.PlanoDeConta;
import br.com.duosoftware.orcamento.entidades.PlanoDeReceita;
import br.com.duosoftware.orcamento.entidades.PrevisaoDeReceita;
import br.com.duosoftware.orcamento.entidades.TipoOrcamento;
import br.com.duosoftware.orcamento.entidades.UnidadeGestora;
import br.com.duosoftware.orcamento.entidades.UnidadeOrcamentaria;
import br.com.duosoftware.orcamento.services.PrevisaoDeReceitaService;
import br.com.duosoftware.orcamento.utils.Mensagens;
import java.io.Serializable;
import java.util.LinkedList;
import java.util.List;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.model.SelectItem;
import org.hibernate.exception.ConstraintViolationException;
import org.primefaces.context.RequestContext;

/**
 *
 * @author Renato
 *
 */
@ManagedBean
@ViewScoped
public class PrevisaoDeReceitaBean implements Serializable {

    private PrevisaoDeReceita previsaoDeReceita;
    private List<PrevisaoDeReceita> previsoesDeReceita;
    private PrevisaoDeReceitaDAO previsaoDeReceitaDAO;
    private PrevisaoDeReceitaService previsaoDeReceitaService;
    //
    ///****Select Itens****
    //
    private List<SelectItem> unidadesGestora;
    private List<SelectItem> unidadesOrcamentaria;
    private List<SelectItem> classificacoes;
    private List<SelectItem> contasDedutoras;
    private List<SelectItem> dedutorasEducacao;
    private List<SelectItem> dedutorasSaude;
    private List<SelectItem> tiposOrcamento;
    private List<SelectItem> incorporacoesPatrimonial;
    private List<SelectItem> vpas;
    private List<SelectItem> calculosCamara;
    private List<SelectItem> calculosPASEP;
    private List<SelectItem> calculosEducacao;
    private List<SelectItem> calculosSaude;
    private List<SelectItem> calculosFUNDEB;
    private List<SelectItem> calculosINSS;
    private List<SelectItem> calculosIRRF;
    private List<SelectItem> calculosISS;
    private List<SelectItem> pagamentos;
    private List<SelectItem> receitasPrimaria;

    public PrevisaoDeReceitaBean() {

        previsaoDeReceitaService = new PrevisaoDeReceitaService();

        previsaoDeReceitaDAO = new PrevisaoDeReceitaDAO();

    }

    public PrevisaoDeReceita getPrevisaoDeReceita() {
        return previsaoDeReceita;
    }

    public void setPrevisaoDeReceita(PrevisaoDeReceita previsaoDeReceita) {
        this.previsaoDeReceita = previsaoDeReceita;
    }

    public List<PrevisaoDeReceita> getPrevisoesDeReceita() {
        if (previsoesDeReceita == null) {
            previsoesDeReceita = previsaoDeReceitaDAO.listarPrevisoesDeReceita();
        }
        return previsoesDeReceita;
    }

    public void setPrevisoesDeReceita(List<PrevisaoDeReceita> previsoesDeReceita) {
        this.previsoesDeReceita = previsoesDeReceita;
    }

    public PrevisaoDeReceitaService getPrevisaoDeReceitaService() {
        return previsaoDeReceitaService;
    }

    public void setPrevisaoDeReceitaService(PrevisaoDeReceitaService previsaoDeReceitaService) {
        this.previsaoDeReceitaService = previsaoDeReceitaService;
    }

    /**
     * <b>Método que inicializa a previsaoDeReceita a ser cadastrado.</b><p>
     *
     * @return void
     *
     */
    public void adicionarInicio() {

        previsaoDeReceita = new PrevisaoDeReceita();
        previsaoDeReceita.setFichaReceita(previsaoDeReceitaDAO.obterSequenciaFichaReceita());

    }

    /**
     * <b>Método que adiciona ou edita uma PrevisaoDeReceita</b><p>
     *
     * Após o término o método fecha o dialog de cadastro.
     * <p>
     *
     * @return void
     *
     */
    public void adicionarEditarFim() {

        previsaoDeReceitaDAO.salvarOuAtualizar(previsaoDeReceita);
        previsaoDeReceita = new PrevisaoDeReceita();
        previsoesDeReceita = null;

        RequestContext requestContext = RequestContext.getCurrentInstance();
        requestContext.execute("dlgPrevisaoDeReceita.hide()");
        requestContext.update("formPrevisoesDeReceita:dtPrevisoesDeReceita");

    }

    /**
     * <b>Método para iniciar o processo de edição de um PrevisaoDeReceita.</b>
     * <p>
     *
     * Ele verifica se há um PrevisaoDeReceita selecionada para edição, se não
     * houver é emitida uma mensagem pedindo que o usuário selecione uma.<p>
     *
     * Caso haja um PrevisaoDeReceita selecionado o médoto abre o dialog para
     * edição<p>
     *
     * @return void
     *
     */
    public void editarInicio() {

        if (previsaoDeReceita == null) {
            Mensagens.mensagemDeAlerta("Selecione um registro", "Selecione um re"
                    + "gistro para Editar");
        } else {
            RequestContext.getCurrentInstance().execute("dlgPrevisaoDeReceita.show()");
        }

    }

    /**
     * <b>Método para iniciar o processo de exclusão de um
     * PrevisaoDeReceita.</b>
     * <p>
     *
     * Ele verifica se há uma PrevisaoDeReceita selecionado para exclusão, se
     * não houver é emitida uma mensagem pedindo que o usuário selecione uma.<p>
     *
     * Caso haja um PrevisaoDeReceita selecionado o médoto abre um p:dialog para
     * confirma ção da exclusão.<p>
     *
     * @return void
     *
     */
    public void excluirInicio() {

        if (previsaoDeReceita == null) {
            Mensagens.mensagemDeAlerta("Selecione um registro",
                    "Selecione um registro para excluir");
        } else {
            RequestContext.getCurrentInstance()
                    .execute("dlgExcluirPrevisaoDeReceita.show()");
        }

    }

    /**
     * <b>Método para excluir um PrevisaoDeReceita.</b>
     * <p>
     *
     * Ele verifica se a PrevisaoDeReceita selecionado para exclusão está sendo
     * utilizado por alguma outra tabela do banco. Se estiver uma mensagem de
     * aviso é dada ao usuário<p>
     *
     * @return void
     *
     */
    public void excluirFim() {

        try {

            previsaoDeReceitaDAO.excluir(previsaoDeReceita);
            previsaoDeReceita = new PrevisaoDeReceita();
            previsoesDeReceita = null;

        } catch (ConstraintViolationException e) {
            Mensagens.mensagemDeAlerta("Registro Utilizado",
                    "Esse registro está sendo utilizado");
        }

        RequestContext.getCurrentInstance()
                .execute("dlgExcluirPrevisaoDeReceita.hide()");

    }

    /**
     * <b> Método para cancelar uma operação de cadastro ou edição.</b>
     * <p>
     *
     * O método instancia um novo objeto na variável PrevisaoDeReceita para
     * limpar as infomações.<p>
     *
     * @return void
     */
    public void cancelar() {

        previsaoDeReceita = new PrevisaoDeReceita();

        RequestContext requestContext = RequestContext.getCurrentInstance();
        requestContext.execute("dlgPrevisaoDeReceita.hide()");
        requestContext.update("formPrevisaoDeReceita:dtPrevisoesDeReceita");

    }

    //get's SelectItens
    //
    public List<SelectItem> getUnidadesGestora() {

        unidadesGestora = new LinkedList<SelectItem>();
        for (UnidadeGestora unidadeGestora : new UnidadeGestoraDAO()
                .listarUnidadesGestoras()) {
            unidadesGestora.add(new SelectItem(unidadeGestora, unidadeGestora.toString()));
        }
        return unidadesGestora;
    }

    //
    public List<SelectItem> getUnidadesOrcamentaria() {

        unidadesOrcamentaria = new LinkedList<SelectItem>();
        for (UnidadeOrcamentaria unidadeOrcamentaria : new UnidadeOrcamentariaDAO()
                .listarUnidadesOrcamentarias()) {
            unidadesOrcamentaria.add(new SelectItem(unidadeOrcamentaria, unidadeOrcamentaria.toString()));
        }
        return unidadesOrcamentaria;
    }

    //
    public List<SelectItem> getClassificacoes() {

        classificacoes = new LinkedList<SelectItem>();
        for (PlanoDeReceita planoDeReceita : new PlanoDeReceitaDAO()
                .listarPlanosDeReceita()) {
            classificacoes.add(new SelectItem(planoDeReceita, planoDeReceita.getClassificacao()));
        }
        return classificacoes;
    }

    //
    public List<SelectItem> getContasDedutoras() {

        contasDedutoras = new LinkedList<SelectItem>();
        for (PlanoDeReceita planoDeReceita : new PlanoDeReceitaDAO()
                .listarPlanosDeReceita()) {
            contasDedutoras.add(new SelectItem(planoDeReceita, planoDeReceita.toString()));
        }

        return contasDedutoras;
    }

    //
    public List<SelectItem> getDedutorasEducacao() {

        if (dedutorasEducacao == null) { //Nos casos em que os dados são FIXOS
            dedutorasEducacao = new LinkedList<SelectItem>();
            for (Confirmacao confirmacao : new ConfirmacaoDAO()
                    .listarConfirmacoes()) {
                dedutorasEducacao.add(new SelectItem(confirmacao, confirmacao.toString()));
            }
        }
        return dedutorasEducacao;
    }

    //
    public List<SelectItem> getDedutorasSaude() {

        if (dedutorasSaude == null) { //Nos casos em que os dados são FIXOS
            dedutorasSaude = new LinkedList<SelectItem>();
            for (Confirmacao confirmacao : new ConfirmacaoDAO()
                    .listarConfirmacoes()) {
                dedutorasSaude.add(new SelectItem(confirmacao, confirmacao.toString()));
            }
        }
        return dedutorasSaude;
    }

    //
    public List<SelectItem> getTiposOrcamento() {

        if (tiposOrcamento == null) { //Nos casos em que os dados são FIXOS
            tiposOrcamento = new LinkedList<SelectItem>();
            for (TipoOrcamento tipoOrcamento : new TipoOrcamentoDAO()
                    .listarTiposOrcamento()) {
                tiposOrcamento.add(new SelectItem(tipoOrcamento, tipoOrcamento.toString()));
            }
        }
        return tiposOrcamento;
    }

    //
    public List<SelectItem> getIncorporacoesPatrimonial() {

        incorporacoesPatrimonial = new LinkedList<SelectItem>();
        for (PlanoDeConta planoDeConta : new PlanoDeContaDAO()
                .listarPlanosDeConta(4, 1)) {
            incorporacoesPatrimonial.add(new SelectItem(planoDeConta, planoDeConta.toString()));
        }
        return incorporacoesPatrimonial;
    }

    //
    public List<SelectItem> getVpas() {

        vpas = new LinkedList<SelectItem>();
        for (PlanoDeConta planoDeConta : new PlanoDeContaDAO()
                .listarPlanosDeConta(4, 4)) {
            vpas.add(new SelectItem(planoDeConta, planoDeConta.toString()));
        }
        return vpas;
    }

    //
    public List<SelectItem> getCalculosCamara() {

        if (calculosCamara == null) { //Nos casos em que os dados são FIXOS
            calculosCamara = new LinkedList<SelectItem>();
            for (Confirmacao confirmacao : new ConfirmacaoDAO()
                    .listarConfirmacoes()) {
                calculosCamara.add(new SelectItem(confirmacao, confirmacao.toString()));
            }
        }
        return calculosCamara;
    }

    //
    public List<SelectItem> getCalculosPASEP() {
        if (calculosPASEP == null) { //Nos casos em que os dados são FIXOS
            calculosPASEP = new LinkedList<SelectItem>();
            for (Confirmacao confirmacao : new ConfirmacaoDAO()
                    .listarConfirmacoes()) {
                calculosPASEP.add(new SelectItem(confirmacao, confirmacao.toString()));
            }
        }
        return calculosPASEP;
    }

    //
    public List<SelectItem> getCalculosEducacao() {
        if (calculosEducacao == null) { //Nos casos em que os dados são FIXOS
            calculosEducacao = new LinkedList<SelectItem>();
            for (Confirmacao confirmacao : new ConfirmacaoDAO()
                    .listarConfirmacoes()) {
                calculosEducacao.add(new SelectItem(confirmacao, confirmacao.toString()));
            }
        }
        return calculosEducacao;
    }

    //
    public List<SelectItem> getCalculosSaude() {
        if (calculosSaude == null) { //Nos casos em que os dados são FIXOS
            calculosSaude = new LinkedList<SelectItem>();
            for (Confirmacao confirmacao : new ConfirmacaoDAO()
                    .listarConfirmacoes()) {
                calculosSaude.add(new SelectItem(confirmacao, confirmacao.toString()));
            }
        }
        return calculosSaude;
    }

    //
    public List<SelectItem> getCalculosFUNDEB() {
        if (calculosFUNDEB == null) { //Nos casos em que os dados são FIXOS
            calculosFUNDEB = new LinkedList<SelectItem>();
            for (Confirmacao confirmacao : new ConfirmacaoDAO()
                    .listarConfirmacoes()) {
                calculosFUNDEB.add(new SelectItem(confirmacao, confirmacao.toString()));
            }
        }
        return calculosFUNDEB;
    }

    //
    public List<SelectItem> getCalculosINSS() {
        if (calculosINSS == null) { //Nos casos em que os dados são FIXOS
            calculosINSS = new LinkedList<SelectItem>();
            for (Confirmacao confirmacao : new ConfirmacaoDAO()
                    .listarConfirmacoes()) {
                calculosINSS.add(new SelectItem(confirmacao, confirmacao.toString()));
            }
        }
        return calculosINSS;
    }

    //
    public List<SelectItem> getCalculosIRRF() {
        if (calculosIRRF == null) { //Nos casos em que os dados são FIXOS
            calculosIRRF = new LinkedList<SelectItem>();
            for (Confirmacao confirmacao : new ConfirmacaoDAO()
                    .listarConfirmacoes()) {
                calculosIRRF.add(new SelectItem(confirmacao, confirmacao.toString()));
            }
        }
        return calculosIRRF;
    }

    //
    public List<SelectItem> getCalculosISS() {
        if (calculosISS == null) { //Nos casos em que os dados são FIXOS
            calculosISS = new LinkedList<SelectItem>();
            for (Confirmacao confirmacao : new ConfirmacaoDAO()
                    .listarConfirmacoes()) {
                calculosISS.add(new SelectItem(confirmacao, confirmacao.toString()));
            }
        }
        return calculosISS;
    }

    //
    public List<SelectItem> getPagamentos() {
        if (pagamentos == null) { //Nos casos em que os dados são FIXOS
            pagamentos = new LinkedList<SelectItem>();
            for (Confirmacao confirmacao : new ConfirmacaoDAO()
                    .listarConfirmacoes()) {
                pagamentos.add(new SelectItem(confirmacao, confirmacao.toString()));
            }
        }
        return pagamentos;
    }

    //
    public List<SelectItem> getReceitasPrimaria() {
        if (receitasPrimaria == null) { //Nos casos em que os dados são FIXOS
            receitasPrimaria = new LinkedList<SelectItem>();
            for (Confirmacao confirmacao : new ConfirmacaoDAO()
                    .listarConfirmacoes()) {
                receitasPrimaria.add(new SelectItem(confirmacao, confirmacao.toString()));
            }
        }
        return receitasPrimaria;
    }
}
